- Alors qu'est ce que le vb6 ??
Le vb6 est un language de programmation,
Il vous permettra de créer des programme qui saurons repondre a vos
attente.
- Est-ce difficile ?
Dire que c'est facile serais vous mentir ! Cela depend de votre determination
et de vos capacités.
Mais comparé a certains autre language de programmations, comme l'ASM
ou le C++
oui, je peut vous dire que le VB6 est simple !
- Que me faut il pour commencer ?
Alors pour programmer en vb6, comme pour tout les autre language de programmation,
il vous faut un logiciel, avec VB6 il se nomme : "Microsoft Visual studio
6"
Alors je vous previens desuite : ce programme est PAYANT ! Il vaut dans les
150 € (mail Emule, Shaeraza, et d'autres P2p existent !).
- Quand commence on ?
Et bien Maintenant!
Dès que vous lancez Microsoft Visual studio 6, une fenetre "Nouveau
projet"
apparait. Dès lors, un choix arrive devant vos yeux ébahis
:
- Onglet nouveau
|
|--> EXE Standart
| --> EXE ActiveX
| --> DLL ActiveX
| --> Controle ActiveX
| --> Assistant creation d'applications
| --> Gestionnaire d'assistant
| --> addin
| --> Aplication DHTML
| --> Aplication IIS
|--> Controle de VB edition entrprise
|--> DLL Document activeX
|--> EXE Document activeX
|--> Projet de donnés
+ Onglet Existant
+ Onglet Recent
Nous voulons créer un nouveau programme, l'onglet "nouveau"
est donc celui qui nous interesse .
Mais la multitude de choix [en chantant] doit vous faire touuurnér
la tééteu...[/en chantant]
Sachez que vous ne vous servirez pas de la pluspart des choix ...
Comme les programmes porte l'extention ".exe", vous vous doutez
bien que le choix qui nous interesse
est le choix "EXE standart".
Vous vous servierez des autre choix qui bien plus tard dans votre apprentissage
du VB6
Vous pourez retrouver vos programmes que vous enregistrerez avec l'onglet "Existant"
et les programmes recement ouvert avec l'onglet "Recent"
Apres avoir choisi "EXE standart", la fenetre "Nouveau projet" disparait.
Vous etes maintenant en face a face avec votre programme. (<= dit comme ça
ca fait peur...)
Vous avez une fenetre "Projet 1 - Form1(Form)"
dans laquelle, une autre fenetre un peu speciale !
En effet, la fenetre dans la fenetre projet1 EST VOTRE PROGRAMME !!! Sans
rien y connaitre en programation
vous savez deja créer une fenetre !!!
En fait cette fenetre va etre la 1ere fenetre de votre programme . Bein
entendu, vous vous doutez bien que
vous pourrez ajouter d'autre fenetre a votre programme !
Vous pouvez modifier sa taille en laissant votre souris appuiée sur un des coin de la fenetre.
Maintenant vous allons voir quelques options essenciels du programme Microfost
Visual Studio.
Une bonne connaisance du programme microsoft visual studio === un bon programme
que vous crérez.
Options les plus importantes :
Fichier
|- Nouveau projet => Réaffiche la fenetre "nouveau projet"
|- Ouvrir un projet => Permet d'ouvir un projet enregistré
|- ...
|- Enregistrer le projet => Enregistrer le Projet en cours
Execution
|- Executer => peremt d'executer votre programme sans que vous ne l'ayaez
| enregistrer
Passons maintenant au plus important :
La boite d'outils : C'est la mini-fenetre située a gauche. C'est
grace a elle que vous pourrez
ajouter des "objets" a votre fenetre (objet => bouton, zone
de texte... etc.)
Alors elle se compose principalememt de :
- Pointeur => selectionez par defaut, peremt de redimentioner, deplacer
les objet de la fenetre
ou la fenetre elle meme
- PictureBox => Permet d'ajouter une image sur votre fenetre.
- Label => Permet d'ajouter du texte
- TextBox => Permet d'ajouter une zone de texte ("modifiable par
l'utilisateur (<= celui qui
vas executer votre programme) contrairement au label
- ChechBox => Permet d'ajouter une case a cocher dans votre fenetre
- OptionButton => Permet d'ajouter une puce a votre fenetre
- Frame => Ne vous servira pas pour le moment...
- CommandButton => Permet d'ajouter un bouton a votre fenetre
- ComboBox => Permet d'ajouter une liste modifiable a votre fenetre
- ListBox => A peu pres correspondant au ComboBox, a la difference
que ce n'est pas une liste.
- [H|V]ScroolBar=> permet d'ajouter des assenceur a votre fenetre
- Timer => Permet d'ajouter un timer a votre fenetre (definition un peu plus loin)
- DriveListBox => permet d'ajouter une liste des disque de l'utilisateur
- DirList Box => permet d'ajouter une liste des dossiers de l'utilisateur
- FileList Box => permet d'ajouter une liste des Fichiers de l'utilisateur
- Shape => permet d'ajouter un objet de forme varié (carré,
cercle, rectangle...etc.)
a votre fenetre
- Line => Permet d'ajouter une ligne a votre fenetre
- Image => Permet d'ajouter un image a votre fenetre
(legerement different sur quelques aspect a la PictureBox)
Il en existe des centaines d'autre (clique droit sur la fenetre barre doutil>Composant)
Mais le but de ce tuto n'est pas de les presneter tous un par un !
Du moins, vou pouvez voir les principaux ci-dessus.
Chaque objet, dont la fenetre elle meme, possede un certain nombre de propriétés
qui
les definissent.
Par exemple, VOUS avez un certain nombre de propriété qui vous
definise :
- votre taille
- votre age
- votre poid
- la couleur de vos cheveux
...etc.
Et bien pour les objet c'est pareil ! Par exemple, pour une TextBox, il
y
aura les propriété :
- Sa taille
- Son positionnement dans la fenetre
- Son contenu par defaut
- sa couleur
...etc.
Vous imaginez donc que la textbox vas avoir un certain nombre de propriété que
les autres
objets n'aurons pas !
Par exemple, il y a une propriété :
- Le texte que contient la TextBox
Il est bien evident que cette propriété n'existe pas pour...
Par exemple la PictureBox
(vus quel contient une image et on du texte).
Alors toute ces propriétés sont visible dans la fenetre "propriété" tout
a droite !
Il vous suffit de cliquer une fois sur l'objet voulue pour que la fenetre
propriete
s'adapte, et vous divulgue les propriétés de l'objet selectionner
!
Bien sur le nom des propriété n'est surement pas ceux a quoi
vous inspiriez je supose !
En effet, c'est un charabia anglais a la limite du compréhensible
! Mais encore une fois, ne vous
inquiettez pas ! en cliquant une fois sur la propriété voulu,
des informations s'afficherons en bas
de la fenetre propriété !
Alors, les propriétés les plus importantes :
Commun a tous les objet :
- Height => propriété de la taille verticale de l'objet
- Left => propriété de l'emplacement horizontal de l'objet
- top => propriété de l'emplacement vertical de l'objet
- widht => propriété de la taille horizontale de l'objet
- name => Nom de l'objet
- visible=> Defini si l'objet est visible ou non
- Enabled=> Defini si l'objet est accesible a l'utilisateur ou non
Pour la PictureBox
- Picture => Defini L'image de la pictureBox
Pour le label
- Caption => Defini le contenu (texte) du label
Pour la textBox
- Text => Defini le contenu (texte) De la textebox
- Multilign => Defini Si, en fonction de la longueur du texte dans la
text box il apparaitra
ou non des assenceurs dans la textbox
Votre programme, dans l'avenir, vas etre composé de plusieur feuilles
et autre.
Tout les composant de votre projet sont visible dans la fenetre "Project"
Cette fenetre est un quelque sorte votre Coqpit
Tout ca est bien joli, mais ou sont passer les lignes de code incompréhesible
qui font toute la beautée de la programmation ?
En effet, pour l'instant vous pouvez croire que je vous ai menti ! Je vous
ai dit
un peu plus en haut que le VB6 etait un language de programmation, or pour
l'instant
vous n'avez pas programmé !!!!! Ne vous inquiettez pas, cela ne saurait
tarder !
Tout ce qui a en haut n'est que le préhenbule a ce qui vas suivre
! (je vous fait peur la non ?)
Maintenant, commençons a nous attaquer aux choses serieuses :
Vous avez beau ajouter tout ce que vous voulez comme objet a votre fenetre,
votre programme n'est pour l'instant qu'un squellete, ou une coque vide !
Par exemple, si vous ajoutez un bouton, et que vous lancez le programme
(F5)
Vous avez beau cliquer sur votre bouton, rien ne se passe ! Et bien c'est
normal, vu que vous
n'avez pas dit au programme ce qu'il doit faire !
Vous allons maintenant créer un programme, qui possede un bouton,
et des que l'on clique sur le bouton,
il s'affiche un message qui diras "Tu viens de cliquez sur le boutton
!!"
Ajoutez donc un bouton a votre fenetre( = feuille, = form) et maintenant,
double cliquez dessus :
la fenetre contenant la fenetre de votre programme disparait et laisse place
a une autre fenetre toute blanche,
qui contient ceci :
Private Sub Command1_Click()
End Sub
Alors qu'est-ce ???? annalysons par ordre...
Private => comprend pa'
sub => comprend pa'
Command1 => Ahhhh ca je sais ce que c'est !!!!!! C'est le nom du bouton
!
_click() => Ben click, ca veu dire cliquer !
end sub => Comprend pa'
Je me suis mis dans votre peau de debutant en VB6 et ai analiser comme vous
l'auriez fait.
En fait tout ce qui vas etre entre ces deux ligne de code vas definir ce
qui vas ne passer quand
on vas "Click()" sur "Command1"
Donc pour n'importe quel objet, on aura
private sub NOM-DE-L'OBJET_ELEMENT-DECLENCHEUR()
'action
end sub
Vous pouvez bien evidemment definir l'element declencheur, en fait, le choisir
parmis une liste !
Par exemple pour notre bouton il y aura :
- quand on clique
- quand ou double clique
- quand on passe la souris dessus
...etc.
Il y en a telement, je ne saurais tous vous les citer ! Mais vous pouvez
les voir et les choisir grace a
la liste deroulante en haut a droite de la fenetre.
Les plus importants pour l'instant sont :
- load => pour la fenetre seulement => Des qu'elle est chargée
(avant quelle ne s'affiche a l'écran)
- unload => pour la fenetre seulement => Des que la fenetre est fermée
- Click => pour a peu pres tout les objet => des que l'on clique dessus
- dblClick => pour a peu pres tout les objet => des que l'on double
clique dessus
- Resize => pour certains objet => des que l'on redimentionne cette
objet
- Got focus => pour a peu pres tout les objet => des que l'objet est
selectionné (= prend le focus)
Ici, vous avons double cliqué sur le bouton que vous avez ajouter
sur la fenetre de votre programme, mais
vous pouvez, bien sur, double cliquer sur, par exemple, sur la fenetre elle
meme, un label ...etc. Touts les objets !
Et donc definir une action pour un evenement precis pour n'importe quel objet
!
Maintenant : petite pause vocabulaire...
tout ceci :
private sub NOM-DE-L'OBJET_ELEMENT-DECLENCHEUR()
'action
end sub
Est appelé PROCEDURE !
Je me devais de vous definir ce mot car je vais l'utiliser des centaines
de fois (j'exagère un peu...)
par la suite !
Les ligne de programmation que l'on vient de voir sont appelé "ligne de code" ou encore "code" ou "source" ou "code source"
Alors maintenant, vous devez vous douter que tout les programmes que vous
verrez par la suite
suivent le meme modelle, celui ci:
Procedure de l'objet A
Procedure de l'objet B
Procedure de l'objet C
Procedure de l'objet D
Procedure de l'objet E
Procedure de l'objet F
...etc.
Le code source de vos programmes ne serons qu'un amas de procedure !
Definir l'action de l'objet X face a une situation Y
Definir l'action de l'objet A face a une situation B
...etc.
Maintenant il ne me reste plus qu'une choses a vous aprendre !
regardez le code ci dessous
private sub NOM-DE-L'OBJET_ELEMENT-DECLENCHEUR()
'action
end sub
Il ne me reste plus qu'a vous apprendre a definir une action
soit ici le " 'action "
Et c'est la que nous allons vraiment penetrer au coeur de la programmation,
nous salir les mains dans le cambouis des fonctions, passer des heures devant
une boucle...
EXITANT N'EST CE PAS ??
Les variables, voici un concept essenciel de la programmation. Quelque soit
le language,
vous retrouverez les variables .
Alors qu'est-ce ? Et bien je vais vous faire la celebre analogie de la boite
!
En fait une variable est une boite, dans laquel je peut mettre tout ce que
je veux :
les lettres, des chiffres ...etc. Alors a quoi cela sert il ?
Et bien imaginez, que dans votre programme vous vouliez repeter 10 fois
la phrase "bonjour m'sieur dame !" .
Au lieu de repeter 10 fois cette phrase, vous pouvez créer une variable
qui s'apellera : "phrase"
et donc au lieu de repeter 10 fois la longue phrase, vous repeterez 10 fois "phrase" .
Maintenant, il faut savoir qu'en VB6 il faut indiquer a notre proramme ce
que l'on vas mettre
dans cette boite ... Pour une variable X, il vas faloir que je donne son
nom ET son type (= le type
de ce quelle vas contenir, exemple : des chiffres, des lettres, un pot pourri
des deux...etc.)
Voici la syntaxe de la ddeclaration d'une variable
dim NomDeLaVariable as TypeDeLaVariable
(NomDeLaVariable doit obligatoirement commencer par une lettre)
Maintenant reste a savoir tout les type de variable...
Les principaux sont les suivant
Integer --------> la variable contiendra de petits chiffres (~ 0 à 255)
Currency -------> la variable contiendra de grand chiffres (trop long a ecrire ;-) )
String ---------> la variable contiendra une chaine de caractère
(chiffre, lettre, enfin tout ce que l'on veut;
longueur indefinie)
Boolean --------> la variable contiendra soit TRUE soit FALSE
Ne vous inquiettez pas si vous ne comprenez pas le type "boolean" ,
je vous expliquerez par la suite !
Alors, sachez qu'une variable déclarée dans une procedure X,
ne pourra etre utilisée que dans cette procedure
X, aucune des autre procedure ne pourra y avoir acces !
Mais il existe une "parade" il est en effet possible de déclarer
une variable de tel sorte qu'elle soit
utilisabe (=visible) partout ! (dans toute les procedure)
Il vous suffit pour cela, d'ecrire ceci :
Option Explicit
' Et ici je declare les variables
' "visible" partout
Mais cette portion de code ne doit pas etre mise dans une procedure mais
dans "l'en tete"
Alors qu'est ce que l'en tete ? Et bien c'est la partie tout tout tout en
haut de votre code,
avant meme les procedure !
EN TETE <----------- ICI
Procedure A
Procedure B
Procedure C
Procedure D
Procedure E
etc...
Reprenons l'exemple de notre fenetre avec seulement le bouton en y rajoutant
quelques petite choses :
Option Explicit
Dim var1 As string
Dim var2 As integer
dim var3 as currency
Private Sub Command1_Click()
Dim varAAAA as string
End Sub
Private Sub Form_Load()
Dim varBBBB as string
End Sub
Les variables var1, var2, et var3 serons utilisable dans les procedures "Command1_Click()" et "Form_Load()"
La variable varAAAA seras utilisable QUE DANS LA PROCEDURE "Command1_Click()"
La variable varBBBB seras utilisable QUE DANS LA PROCEDURE "Form_Load()"
Maintenant quand je dit "utilisable", reste a se que vous sachier les utiliser !!!!
Vous pouvez utiliser des variables, coooool, mais ça sert a quoi ?
et bien par exemple vous pouvez additioner, soustraire, multiplier, diviser
des variables !
et bien entendu vous pouvez definir le contenu d'une variable !!
Exemple :
Dim var1 As integer 'J'indique au programme que les variable vonr contenir
que des chiffres
Dim var2 As integer ' grace au type integer !
dim var3 as integer ' Mais je ne pourrais pas y mettre de trop grand chiffres
...
var1 = 2 ' la variable ' "var1" a desormais pour contenu "2"
var2 = 5 ' la variable ' "var2" a desormais pour contenu "3"
var3 = var1 + var2 ' la variable "var3" a pour contenu var1+var2 soit 2+5 soit 7
Comme vous l'auriez compris, tout ce qui suit un apostrophe n'est pas pris
en compte par le programme
et permet donc d'y mettre des note dedans !
Voila pour cette exemple plutot simpliste ! mais maintenant jouons en peut
avs les operateur !
(operateur = + - * / ... permet de traiter des informations)
Dim var1 As integer
Dim var2 As integer
dim var3 as integer
var1 = 2 ' la variable ' "var1" a desormais pour contenu "2"
var2 = 5 ' la variable ' "var2" a desormais pour contenu "3"
var3 = var1 + var2
var3 = var3 / 7
var2 = var2 + (var3 - 1)
var3 = 10
var2 = var3
var1 = var3 * var2
var1 = var1 / 100
Quel est la valeur de var1 ???
alez, procedons par ordre =
- Var3 = var1 + var2 ' 5+2 = 7
- var3 = var3 / 7 ' 7/7 = 1
- var2 = var2 + (var3 - 1) ' 5+(1 - 1) = 5 = var2
- var3 = 10 ' 10
- var2 = var3 ' 10
- var1 = var3 * var2 ' 10 * 10 = 100
- var1 = var1 / 100 ' 100 / 100 = 1
Var1 est egal a 1 !!
Maintenant tous allons voir un operateur tres important : &
Voyons le en action avec un exemple ...
Dim var1 As String
Dim var2 As String
dim var3 as String
var1 = "bonjour comment ca va"
var2 = " ilsa ?"
var3 = var1 & var2
En fait l'operateur "&" vas assembler les deux variable !
var3 est donc egale a "bonjour commebt ca ilsa ?"
Mais ecrire ce que nous avons fait ci-dessus, revient a ecrire cela :
Dim var1 As String
Dim var2 As String
dim var3 as String
var3 = "bonjour comment ca va" & " ilsa ?"
/\
/ \
---- ATTENTION : Comme vous l'avez remarquer, quand on defini le contenu
d'une variable qui vas contenir
que des chiffre, on a pas besoin de mettre des parhenthèse ! Par contre
quand on vas definir une variable
qui vas contenir une chaine de caractère quelquonque, il FAUT mettre
cette chaine entre parhenthèse !
(ce qui est logique ! Comme je vous l'ai dit un peut plus en haut, une variable
ne PEUT PAS commencer par un chiffre
donc si on donne pour contenu une chaine de caractère sans parhentèse,
le programme pourais croire que cette chaine
est en fait une variable, il vas la rechercher, ne pas la trouver et provoquer
une erreur !)
Quoi ?? Encore ??? mais on les a deja vus !!!!!!
Mais neuu vouuuuus inquieeeeeeteeeeezz paaaaaaaas !!
Je vais maintenant vous apprendre a modifier les propriétés
d'un objet quelquonque
a partir du code !!!
col non ?
et pour conclure ce chapitre, nous allons créer une petite calculatrice
!! si si !!
Alors pour modifier les propriétés, c'est tres simple !! Il faut proceder comme ceci :
NomDeLObjet.Propriete = valeur
exemple :
label1.caption = "vous avez vus !! j'ai modifier la proprio caption
!!!"
La propriété caption, comme dit plus haut, etant la propriete
qui contient le texte du label.
Par exemple, vous allons faire un petit programme qui, des que l'on vas cliquer
sur un bouton vas
changer le contenu de la textbox "text1" :
Private Sub Form_Load()
text1.text = ""
End Sub
Private Sub Command1_Click()
text1.text = "mais c'est pas beau ça ??"
End Sub
En français ca donne : Des que la feuille "Form" va etre
affiché a l'écran, la propriété
"
text" de la textbox "text1", qui contient le contenu de la
textbox, vas devenir "" soit rien
Et des que je vais cliquer sur le bouton "Command1", La propriété "text" de
la textBox "text1"
vas devenir "mais c'est pas beau ça ??"
Maintenant, vous avez les connaisances necessaires a la creation d'un caclulatrice
!!!
Faison le point, vous savez :
- manier Le logiciel Microsoft Visual studio
- acceder au code (la procedure) d'un objet X
- definir l'élément declencheur de la procedure d'un objet
- declarer des variables de tout type
- manier ces variable (definir contenu, soustraire, multiplier, assembler...
etc.)
- modidifer les paramètre d'un objet X a partir du code
Vous vous ammeliorez serieusement ! Quand vous avez commencer a lire ce
tuto, vous n'y connaisiez
rien au VB6, et la vous etes sur le point de créer une calculatrice
!
Donc, avant de créer tout programme, il faut qu'il soit bien clair
dans votre tete.
Reflechisons au objets que vous allons inserer a la form...
- une textBox, dans laquel il y aura le resultat
- 5 boutons pour : additioner, soustraire, multiplier, diviser et afficher
le resultat
ainsi que 10 autres boutons : un pour chaque chiffre.
Donc, commencez a inserer d'une manière "ordonée" ces
objets...
Maintenant nous reste a aller dans le code pour donner vie a votre calculatrice
.
Sachez que grace a cette calculatrice, je vais introduire un certain nombre
de
concepts jamais vu auparavant, ne vous inquiettez donc pas, je vais expliquer
!
(les concepts sont = les tableau, et les conditions)
------------CUT-HERE-8<----------------------------------------------------------------------------------------------
Option Explicit ' grace a option explicit, les variable que je vasi declarer
' en dessous seront visible dans toute les procedures !
Dim chiffre(1 To 2) As Integer ' je declarer ici en fait 2 variables
' la variable chiffre(1)
' et chiffre(2)
'qui vont contenir les chiffres a calculer
Dim queloperateur As Integer ' variable, qui selons l'operateur ( + - / * )
choisi
' par l'utilisateur, changera de valeur
' pour le calcul final contenu dans la procedure du
' bouton "="
Dim tablo As Integer ' variable qui vas varier de 1 a 2 (toujour "1" avant
' que l'utilisateur ne choisise un operateur
' et apres le choix d'un operateur, elle devient "2"
'--- et tou ceci vas nous permettre de mettre les chiffres
' entrés par l'utilisateur SOIT dans chiffre(1), SOIT
' dans chiffre(2)
Private Sub Form_Load()
tablo = 1 'des le lancement du programme
'la variable tablo vas prendre la valeur
'de "1"
'donc tout les chiffres entrés par l'utilisateur
'seront stoqué dans chiffre(tablo)
'soit chiffre(1)
End Sub
Private Sub Command7_Click()
'procedure du bouton "1"
'comme tablo = 1
'chiffre(tablo) correspond a chiffre(1)
'donc les chiffre sont stoqué dans la variable
'chiffre(1)
chiffre(tablo) = chiffre(tablo) & 1 'chiffre(1) est egale a lui meme ET
1
' (et non pas PLUS 1)
Text1.Text = chiffre(tablo) ' et on affiche le tout dans la textbox
End Sub
Private Sub Command8_Click()
'procedure du bouton "2"
'comme tablo = 1
'chiffre(tablo) correspond a chiffre(1)
'donc les chiffre sont stoqué dans la variable
'chiffre(1)
chiffre(tablo) = chiffre(tablo) & 2 'chiffre(1) est egale a lui meme ET
2
' (et non pas PLUS 2)
' et on affiche le tout dans la textbox
Text1.Text = chiffre(tablo)
End Sub
' Comme vous l'aurez compris, apres, toute les procedures des boutons
'"1 2 3 4 5 6 7 8 9" suivrons le meme modele
' pas besoin donc de les commenter
Private Sub Command9_Click()
chiffre(tablo) = chiffre(tablo) & 3
Text1.Text = chiffre(tablo)
End Sub
Private Sub Command4_Click()
chiffre(tablo) = chiffre(tablo) & 4
Text1.Text = chiffre(tablo)
End Sub
Private Sub Command5_Click()
chiffre(tablo) = chiffre(tablo) & 5
Text1.Text = chiffre(tablo)
End Sub
Private Sub Command6_Click()
chiffre(tablo) = chiffre(tablo) & 6
Text1.Text = chiffre(tablo)
End Sub
Private Sub Command1_Click()
' procedure du bouton "7",
chiffre(tablo) = chiffre(tablo) & 7
Text1.Text = chiffre(tablo)
End Sub
Private Sub Command2_Click()
chiffre(tablo) = chiffre(tablo) & 8
Text1.Text = chiffre(tablo)
End Sub
Private Sub Command3_Click()
chiffre(tablo) = chiffre(tablo) & 9
Text1.Text = chiffre(tablo)
End Sub
Private Sub Command10_Click()
chiffre(tablo) = chiffre(tablo) & 0
Text1.Text = chiffre(tablo)
End Sub
'------------------------------------------------------------
' A partir de la, on passe au procedure des boutons "operateur" (
+ - * /)
Private Sub Command12_Click()
queloperateur = 1 ' Ici la variable "queloperateur" prend la valeur
de 1
' C'est cette variable qui vas determiner, quand on vas cliquer
' Sur le bouton " = ", quel operateur a été choisis
'-------------------------------------------------------------
tablo = 2 ' ATTENTION !! Desormais "tablo" est egal a 2 !!!! Apres
avoir cliquer
' sur un operateur, le chiffre qui vas etre entré par l'utilisateur
vas
' etre stoqué dans une AUTRE variable : chiffre(tablo) soir chiffre(2)
' alors qu'avant d'avoir cliqué sur un operateur, il etait stoqué dans
' chiffre(tablo) mais tablo etait égale a 1 !
End Sub
' Meme contruction pour touts les "boutons operateur", suel la
valeur de
' "queloperateur" change
Private Sub Command13_Click()
queloperateur = 2
tablo = 2
End Sub
Private Sub Command14_Click()
queloperateur = 3
tablo = 2
End Sub
Private Sub Command15_Click()
queloperateur = 4
tablo = 2
End Sub
'------------------------------------------------------------
' et la on passe a la procedure du bouton " = "
Private Sub Command16_Click()
If queloperateur = 1 Then ' SI queloperateur est egal a 1
Text1.Text = chiffre(1) + chiffre(2) ' ALORS la textbox text1 vas afficher
la somme de chiffre1 et chiffre1
End If ' FIN de la CONDITION
If queloperateur = 2 Then ' SI queloperateur est egal a 2
Text1.Text = chiffre(1) - chiffre(2) ' ALORS la textbox text1 vas afficher
la difference de chiffre1 et chiffre1
End If ' FIN de la CONDITION
If queloperateur = 3 Then ' SI queloperateur est egal a 3
Text1.Text = chiffre(1) * chiffre(2) ' ALORS la textbox text1 vas afficher
la multiplication de chiffre1 et chiffre1
End If ' FIN de la CONDITION
If queloperateur = 4 Then ' SI queloperateur est egal a 4
Text1.Text = chiffre(1) / chiffre(2) ' ALORS la textbox text1 vas afficher
la division de chiffre1 et chiffre1
End If ' FIN de la CONDITION
End Sub
------------CUT-HERE-8<----------------------------------------------------------------------------------------------
Et voila pour notre calculatrice ... alors vous allons un peu nous attarder sur les nouveau concepts ok ?
Alors de petites explications s'imposent non ?
En fait les tableau sont les outils des fegniants ! Ils evitent de se repeter
!
Comme vous l'avez vu ci dessus, au lieu de declarer 2 variables chiffre(1) et chiffre(2) comme ceci :
dim chiffre(1) as integer
dim chiffre(2) as integer
J'ai preferer faire
dim chiffre(1 to 2) as integer
Bien sur, ici c'est assez "stupide", mais quand je veux declarer
1000 variables, deja ca devient plus interessant !
la syntaxe est donc la suivante :
dim NomDeLaVariable(x to y) as Type
ça resemble a une declaration normale, seul "(x to y)" est
rajouté, ou x et y sont des entiers naturels > 0
Il y a quand meme une difference tres importante que je ne vous ai pas dite,
et qui m'a fait preferer le choix
des tableau dans la calculatrice plutot que la declaration de 2 variable
:
C'est que comme vous l'avez vu dans le code, je peut "inserer" une
AUTRE variable entre les parhentèses avec les tableau
contrairement avec la declaration de deux variables.
Exemple :
CE QUE JE PEUT FAIRE :
Dim chiffre(1 to 10) as integer
Dim repaire as integer
repaire = 5
chiffre(repaire) = 100
CE QUE JE NE PEUT PAS FAIRE
dim chiffre(1) as integer
dim chiffre(2) as integer
dim chiffre(3) as integer
dim chiffre(4) as integer
dim chiffre(5) as integer
dim chiffre(6) as integer
dim chiffre(7) as integer
dim chiffre(8) as integer
dim chiffre(9) as integer
dim chiffre(10) as integer
dim repaire as integer
repaire = 5
' jusqu'ici tout vas bien ...
' ...ET LA... C'EST LE DRAME
chiffre(repaire) = 100
-------------------------------------------------------
Le programme vas chercher la variable "chiffre(repaire)" et non
pas la variable "chiffre(5)"
Ne vas pas la trouver et provoquer une erreur.
CONTRAIREMENT ave les tableaux !
Une exemple vous expliquera surememnt mieux que moi...
IF (CONDITION) THEN
' ici action si la condition est vrai
ELSE
' ici action si la condition n'est pas vrai
END IF
Voici donc la syntaxe des condition ...
Alors faison un petit """"exercice"""
Dite moi quel valeur aura la variable var1
Dim var1 as integer
if (1=2) then
var = 1
else
var = 2
end if
Alors ? Et bien oui, la valeur de "var1" est "2" ! Traduisons
ces petite lignes de code en français :
--- --- --- --------
Création de la boite var1 qui est destiné a contenir des chiffre
(petits chiffes)
SI 1=2, var1 vas contenir 1
AUTREMENT var1 vas contenir 2
--- --- --- --------
Bien sur, le "else" est optionel comme vous avez pus le voir dans
l'exemple de la calculatrice
Maintenant, a la place du "=" dans l'exemple vous pouvez mettre un des operateur suivants :
< inferieur
>
supperieur
<
= inferieur ou egal
>
= supperieur ou egale
<>
different de
exemple
if (var1<>var2) then
'action
else
'action autre
end if
Les boucles, tout comme les tableau, sout les outils des feignants !
elles permettent de repeter une portion de code !
Il en existe 2 types :
celles qui repete une portion de code X fois
celles qui repete une portion jusqu'a qu'une condition soit vrai ou fausse
Commençons par celles qui repete une portion de code X fois, on les
apelle les boucles "FOR"
en voici la syntaxe :
for var1 = x To y step z
'portion de code
next var1
- la varviable "var1" ne doit pas etre definie auparavant (bizzard
non ?)
- x, y, z sont des chiffres quelonque
Alors qu'est ce que ce charabia veut il bien dire ??
Et bien la variable var1 vas prendre succesivement les valeur de x a y par
saut de z :
a chaque fin de boucle, var1 = var1 + z
et des que var1=y, la boucle s'arrete.
Par defaut, z=1
et le "next var1" delimite la boucle
Exemple :
For intI = 1 to 10 step 0.5
text1.text = intI
next intI
Alors la variable "intI" vas prendre les valeur de 1 a 10 par
pas de 0.5
alors intI vas prendre les valeur suivante :
intI = 1
intI = 1.5
intI = 2
intI = 2.5
intI = 3
intI = 3.5
intI = 4
intI = 4.5
intI = 5
intI = 5.5
intI = 6
intI = 6.5
intI = 7
intI = 7.5
intI = 8
intI = 8.5
intI = 9
intI = 9.5
intI = 10
la boucle vas donc ce repeter 20 fois (10 / 0.5) !
Alors pourquoi ne pas faire :
For intI = 1 to 20
text1.text = intI
next intI
(quand le step est absent, c'est comme si il y avait "step 1" )
Et bien, la textbox "text1" n'affichera pas les meme choses !
(meme si ca ira telement vite que vous ve pourrez pas voir ce qui vas se
passer !)
Apres, vous pouvez faire toute sorte de choses !
Exemple :
For intI= 1 to 2
if reponse = "faux"
intI = 1
end if
'action
Next intI
Par exemple, cette boucle se repetera a l'infini tant que la variable reponse
=faux !
Mais il existe plus simple comme type de boucle qui continu/arrete de se
repeter des qu'une condition est fausse/vrai
Ce sont les boucles "DO", il en existe 2 variantes, et voici les
syntaxes des deux :
DO
'action
LOOP WHILE(condition)
et
DO
'action
LOOP UNTIL(condition)
Les deux "variantes" sont a peu pres similaires, seul le WHILE
et le UNTIL change !
- La première vas se repeter TANT QUE LA CONDITION EST VRAI
- La deuxieme vas se repeter JUSQU'A QUE LA CONDITION SOIT VRAI
Exemple en français :
1 :
Tant que(=>WHILE) l'assiete est pleine(=>condition), tu continue a
manger (=>'action)
2:
Jusqu'a que(=>UNTIL) tu vomisse(=>condition), tu continu a manger(=>'action)
Maintenant, exemple en vb6 :
dim col as integer
col = 0
Do
col = col + 1
Loop while(col < 10)
Aller, petite devinete, combien de fois vas se repeter la boucle ? et bien
10 fois !
La boucle continura tant que col < 10, or a chaque tour de boucle, j'incremente "col" de
1
et au bout de 10 tour, la condition ne sera plus vrai !
KapiChé ?
Maintenant petit exemple avec UNTIL :
dim col as integer
col = 0
Do
col = col + 1
Loop until(col = 10)
La pareil, la boucle se repetera jusqu'a que col soit egal a 10, et comme
il est egal a zero et qu'a
chaque tour je l'incremente de 1, au bout du 10eme tour, la condition sera
vrai !
Le timer est un objet ! (icone en forme de chronomètre dans la fenetre
outil)
Alors pourquoi le mettre ici ??? Et bien c'est qu'il doit y avoir un petit
rapport avec le titre le la "leçon" non?
et bien tout ce que vous mettrez dans la procedure d'un timer se repetera
toute les "interval" miliseconde
ou "interval" est une propriété du timer !
col non ?
Alors qu'est ce que le "case", Et bien c'est encore un outil de
feignant... Qui pourrait etre remplacer
par des condition (if) mais avec "case" ca vas 100 fois plus vite
!!!
Voyons ca dans un petit exemple:
Dim note As Integer
note = text1.text
Select Case note
Case 20
label1.caption = "bien"
Case 0
label1.caption = "pas bien"
End Select
Vous comprenez ? En fait il vas y avoir un test ! Si "note" =
20 alors j'affiche "bien"
et si note = 0 alors j'affiche "pas bien"
Comme vous l'avez vu la sytaxe est la suivante :
Select case VARIABLE
case XX
'action
case YY
'action
'autant de case que l'on veut...
End Select
Mais maitenant voyons un exemple plus... utile ! Un petit programme créer
par votre mère dans lequel vous devez entrer vos
notes et que, si la note entrée est supperieur a 10, alors vous avez
un message de felicitation, autrement, on vous enguele !
Dim note As Integer
note = text1.text
Select note cool
Case Is > 10
label1.caption = "bien mon enfant"
Case Is < 10
label1.caption = "OOHH c'est quoi cette note ??? ca vas pas ???"
End Select
en mettant "case is" vous pouvez utiliser un operateur de superiorité,
inferiorité, egalité ou inegalité
OULA ! Aïïe ! C'est QUOI ce mot barbare ?? Que vous retrouverez
dans tout les languages de programmations ???
Et qui fait SI PEUR ????
Ne vous inquietez pas, vous aurez du temps, beauuuuucoup de temps pour le
savoir avec ce lonnnnnng chapitre !
- comment reconnaitre une fonction ?
Alors la : rien de plus simple ! Elles suivent tout la forme suivante :
unevariable = NomDeLaFonction()
Mais attention les fonctions suivent toute cette forme mais cette forme n'est
pas toujour synonyme de fonction !!
Alors a quoi sert une fonction ? A traiter des informations, par exemple
une fonction qui transformera tout les caractère
minuscules en majuscule dans une variable donnée :
unevariable = FonctionMajuscule(variableAtraiter)
On dit que la variable "variableAtraiter" est un argument de la
variable... Il n'y a rien a comprendre, c'est
du vocabulaire ! Re Exemple :
unevariable = FonctionX(var1, var2, var3)
Var fonction "FonctionX" vas avoir pour agument les variables
var1, var2 et var 3 !
Alors il existe des fonction pour tout ! Voyon en quelques unes !
-----------------------------------------------------------------
-----------------------------------------------------------------
fonction de conversion en entier.
Int(numericValue)
Fic(numericValue)
-----------------
ici numericValue est litteral, une variables ou une expression numerique
et
meme une fontion imbriquée capable de renvoyé un nombre
ces fonction ARRONDISSENT :
intAns1 = Int(6.8) '7 (arrondi au supperieur)
intAns2 = Fix(6.8) '6 (a l'inferieur)
intAns3 = Int(-6.8) ' -7
intAns4 = Fix(-6.8) ' -6
Abs() = fonction interne qui permet de calculer les valeur absolues
-------
exemple:
intAgeDifference = abs(intAge1 - intAge2)
quelque soit la personne la plus agés, le resultat sera tjr POSITIF
sqr()= donne la racine carrée d'un nombre positif
------
intVal1 = Sqr(64) '8
sqr() renvoi aussi la racien carrée exacte des valeurs decimales
Exp() : renvoi la base d'un logarithme naturel naturel (nbr e : 2.7182282)
------ élevé a la puissance de l'argument
Log() : renvoi logarithme naturel de l'argument
------
Atn() : renvoi la tangente d'arc de l'argument en radian
------
Cos() : de meme mais le cosinus
------
Sin() : de meme mais le sinus
------
tan() : de meme mais le sinus
pour appliquer une fonction trigonometrique à une valeur
en degres et non en radian, il faut
multiplier l'argument par (pie / 180)
-----------------------------------------------------------------
-----------------------------------------------------------------
fonction conversion de type données
----------------------------------
Fonction | converti l'argument en :
-------------------------------------
CBool() | Boolean
-------------------------------------
CByte() | Byte 'type de variable que nous utiliserons tres peu...
-------------------------------------
CCur() | Currency
-------------------------------------
CDate() | Date 'type de variable que nous utiliserons tres peu...
-------------------------------------
CDbl() | Double 'type de variable que nous utiliserons tres peu...
-------------------------------------
CDec() | Decimal'type de variable que nous utiliserons tres peu...
-------------------------------------
CInt() | Integer
-------------------------------------
CLng() | Long'type de variable que nous utiliserons tres peu...
-------------------------------------
CSng() | Single'type de variable que nous utiliserons tres peu...
-------------------------------------
CStr() | String
-------------------------------------
CVar() | Variant 'type de variable que nous utiliserons tres peu...
-------------------------------------
exemple :
curVar1 = CCur(123) 'convertit 123 en currency
_____________________________________________
CInt() arondi l'argu à l'entier le + proche
------
intA1 = CInt(8.5) ' affecte valeur 8 a intA1
intA2 = CInt(8.5001) ' affecte valeur 9 a intA2
___________________________________________________________
___________________________________________________________
___________________________________________________________
___________________________________________________________
___________________________________________________________
FONCTION DE CHAINES
-------------------
la fonction Len()
-----
cette fonction renvoi le nombre de caractères de l'arguemnt
syntaxe :
Len(var1)
EXEMPLE :
----------------------
Private Sub Command1_Click()
lbl.Caption = Len(txt.Text)
End Sub
----------------------
ou
----------------------
Private Sub Command1_Click()
Dim prout As String
prout = txt.Text
lbl.Caption = Len(prout)
End Sub
----------------------
___________________________________________________________
___________________________________________________________
___________________________________________________________
___________________________________________________________
___________________________________________________________
Conversion de chaines
Fonction | converti l'argument en :
------------------------------------------------------
Cstr() | chaines
------------------------------------------------------
Str () | converti l'argument numerique en chaines
------------------------------------------------------
Val () | converti l'argument chaine en nombre
------------------------------------------------------
___________________________________________________________
___________________________________________________________
___________________________________________________________
___________________________________________________________
Fonction ASCII
chr() et Asc() permetten de convertir chaine en sa valeu ascii et vice versa
----- -----
la fonction Asc() et l'exact inverse de chr()
---- -----
chr() recoi argument numerique et renvoi un caractère
et Asc() recoi en caractère et revoi un numero
strVar = Chr(97) 'stocke "a" dans strVar
---------------------
' chr(241) donne un n titde
strMyQuest = Chr(191) & "Como esta, " & "Se" & Chr(241) & "orita
ariba ariba ! ?"
-----------------------
-----------------------------------------------------------------
-----------------------------------------------------------------
msgbox() , fonction interne
msgbox est une fonction qui vas permettre d'afficher un petit message paramètrable.
les arguments que nous allons donner a la fonction msgbox() determine l'icone
qui serra affichée,
le message et le nombre de boutton de commande
Lorsque que nous utilisons MsgBox() , la fonction vas revoyer une valeur
pour indiquer sur quel bouton l'utilisateur
a cliqué : imaginez nous dans la situation ou grace a msgbox nous
posons une question a l'utilisateur, et il a le choix
entre les reponse "oui" ou "non" et bien la fonction
msgbox vas nous INDIQUER sur quel bouton l'utilisateur a cliqué
syntaxe :
intReponse = msgbox(VarLeMessage, VarLeStyle, VarLeTitre)
varLemessage vas etre bien entendu le message, VarLeStyleD : le type de
l'icone affiché a coté du message
ainsi que les bouton possible (oui non ; annuler continuer ...etc.)
et enfin VarLetitre : le titre !
Avec msgbox() ,les argument VarLeStyleDeLicone et VarLetitre sont OPTIONELS
: on est pas obligé de les mettre
exemple simple :
varMessage = msgbox("cliquez pour lancer l'impression")
TABLEAU DES VALEUR ENTIERES PERMETTANT DE SPECIFIER LE STYLE DES BOUTTONS
valeur | constante nommée | Description
--------------------------------------------------------------
0 | vbOkOnly | Bouton OK
--------------------------------------------------------------
1 | vbOkCancel | Boutons OK, Annuler
--------------------------------------------------------------
2 | vbAbordRetryIgnore | Boutons Abandonner , réessayer, ignorer
--------------------------------------------------------------
3 | vbYesNoCancel | Boutons Oui, Non, Annuler
--------------------------------------------------------------
4 | vbYesNo | Boutons Oui, Non
--------------------------------------------------------------
5 | vbRetryCancel | Boutons Réessayer, Annuler
--------------------------------------------------------------
exemple :
intReponse = MsgBox("Pret pour l'impression ?", 1)
(correspond aussi a :
intReponse = MsgBox("Pret pour l'impression ?", vbOkCancel)
TABLEAU ICONE BOITE DE MESSAGE
valeur | constante nommée | Description
--------------------------------------------------------------
16 | vbCritical | erreur critique
--------------------------------------------------------------
32 | vbQuestion | question
--------------------------------------------------------------
48 | vbExclamation | Avertissement
--------------------------------------------------------------
64 | vbInformation | Information
--------------------------------------------------------------
TABLEAU DES VALEURS RENVOYES QUI INDIQUENT QUELS BOUTTONS ON ETE CLIQUES
valeur | constante nommée | Description
--------------------------------------------------------------
1 | vbOk | l'utili a cliqué sur OK
--------------------------------------------------------------
2 | vbCancel | l'utili a cliqué sur Annuler
--------------------------------------------------------------
3 | vbAbort | l'utili a cliqué sur Abandonner
--------------------------------------------------------------
4 | vbRetry | l'utili a cliqué sur Réessayer
--------------------------------------------------------------
5 | vbIgnore | l'utili a cliqué sur Ignorer
--------------------------------------------------------------
6 | vbYes | l'utili a cliqué sur Oui
--------------------------------------------------------------
7 | vbNo | l'utili a cliqué sur Non
--------------------------------------------------------------
si l'utilisateur fait échap, la valeur renvoyé est 2 (comme si
Annuler)
La valeur vas bien entendu etre stoqué dans la variable qui contiendra
msgbox !
euh... un petit exemple serais la bienvenue non ?
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
Private Sub Form_Load()
Dim lemessage As String
lemessage = MsgBox("ca va ?", vbCritical + vbOKCancel, "euh ...")
If lemessage = vbCancel Then
lemessage = MsgBox("Qu'est ce qui a vieux frère ?? ca va pas
???", vbinformation, "qu'est ce qui a ??")
End If
If lemessage = vbOK Then
lemessage = MsgBox("Impec ! super col !", vbinformation, "cooooooooool")
End If
End Sub
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
-----------------------------------------------------------------
-----------------------------------------------------------------
Maintenant une fonction vachement importante, la fonction mid()
alors la fonction mid prend 3 arguments mais... mais d'abord je devrais peut
etre
vous dire a quoi elle sert ! Elle sert a prendre X caractères a partir
du Yeme dans une chaine de caratère Z
SYNTAXE :
mid(ChaineDeCaractère, NumeroDeCaractèreOuOnCommence, NombreDeCaractèresAprelever)
Exemple :
dim col as string
lemessage as string
col = "salut mon pote"
col = mid(col, 6, 3)
lemessage = msgbox(col)
en français ca donne :
Je declare la variable "col" et "lemessage"
col vas contenir la phrase "salut mon pote" puis col
vas etre égale a mid(col,1 ,5) oups... erreur de traduction
je traduis la ou la fonction entre en jeux :
Je vais traiter la variable "col", je vais partir du 6eme caractère
et prelever les 3 suivants
col vas donc etre egale non plus a "salut mon pote" mais a "mon"
Puis j'affiche le resultat avec la fonction msgbox()
-----------------------------------------------------------------
-----------------------------------------------------------------
Allez, plus que 2 autres fonction et je vous lache avec ca !
encore des fonctions tres tres importante, les fonction Ucase() et Lcase()
elle permetent de transformer leurs UNIQUE argument tout en majuscule (Ucase())
ou tout en minuscule (Lcase())
exemple :
Dim col As String
Dim messageexpres as string
col = "sAlUt MoN PoTe"
col = UCase(col)
messageexpres = MsgBox (col)
col = "sAlUt MoN PoTe"
col = LCase(col)
messageexpres = MsgBox (col)
[en chantant]Voili voilou ce s'ra tout' [/en chantant]
Si vous etes comme moi dans mon apprentisage du vb6, et bien il ne me tardait
qu'une seule choses : savoir lier
plusieurs forme (et traiter les fichiers mais ce n'est pas pour maintenant)
.
Par exemple, des que je clique sur le bouton "command1" de la fenetre
form1, et bien celleci disparait et laisse place
a une autre fenetre (=form) "form2"
col non ? Et bien je vais vous apprendre ca !!!!
Et oui ! Avant de lier des form (= fenetre (je me répète la
non ?)) il faudrai peut etre en ajouter plusieurs non?
logique ! Et pourtant...
Enfin, pour ajouter une form, il vous suffit de faire un clique droit dans
la fenetre "projet" (en haut a droite) puis :
ajouter>feuille>form
Et la : maaaaaagique ! Vous avez une autre feuille tout nouvelle toute belle
devant vos yeux ebahis ! (Vous pouvez revenir et retoucher
nimporte que feuille (=form (huhuhu)) dans la fenetre projet(en double cliquant
sur la form(=feuille) (ah ah ah) de son choix)
Sur une étoiiiile sur un oooréééilééééé ééééé ...
hum...
Donc... LIONS !!
Imaginons la situation, vous avez dans votre projet 2 feuilles, l'une form1
l'autre form2
Sur chaqu'une des form un bouton "command1" et vous voulez que
des que l'on clique sur le bonton, ou vas sur l'autre feuille
et bien c'est tres simple, on vas (encore une fois) Toucher au propriétés
(meme si ca n'en est pas vraiment mais bon...)
pour afficher une feuille, je fait
NomDeLaForm.show
et pour la cacher :
NomDeLaForm.hide
Donc des que l'on vas cliquer sur le bouton de la form1, on vas afficher
la form2 donc:
form2.show
et on se cache pour que seul la form2 soit visible :
form2.show
form1.hide
et l'inverse avec la form2 :
form1.show
form2.hide
Voili voilou ! Tres Simple et tres tres efficace ;-)
Alors, encore un tres cours chapitre pour vous introduire une notion hyper
mega importante !
Alors qu'est ce qu'un module ? Un module est comparable a l'entete du code
source d'une feuille
(vous savez, "option explicit", la ou on place les variables visibles
partout !!)
Sauf qu'avec les entete, toutes les variables declares ne sont visible QUE
et UNIQUEMEMNT QUE dans toute
les procedure de la form dans laquel les variables on été déclarés
!
Donc une variable declarée dans l'entete dans une form1 est visible partout dans cette form1 mais pas dans la form2 !!
Les modules sont un remede a ce probleme !!
En effet tout ce qui est declarer dans un module est visible PARTOUT mais
alors PARTOUT dans le programme
dans la form1 comme dans la form2 !
Cool non ?
Mais alors comment en ajouter ??
Et bien faite comme pour ajouter une feuille (clique droit sur la fenetre
projet > ajouter > mais la => MODULE > puis ouvrir)
voila, vous acceder a une feuille tout blanche comme neige dans laquel vous
pouvez, et sans marquer "option explict", declarer
des variables visibles absoluments partout !
OOHH non !!! Pas encore les fonction .........
Mais non ! Je ne vais pas vous faire ici une liste de toute les fonciton
mais je vais
vous apprendre a en créer une !!! Pourquoi maintenant et non pas dans
la partir fonction interne ?
Et bien parce que j'avais besoin de vous introduire le concept de module
pour vous apprendre cela !
Donc, vous allons créer une fonction... mais pourquoi ? Et bien c'est
cool d'avoir une fonction qui puisse
rempondre a ses besoin ! Qui puisse traiter d'une façon speciale une
variable...
Par exeple, vous allons prendre ici l'exemple de la mère, qui vas
créer une fonction "note" qui vas
verifier les notes entrer par son fils...
Avant tout choses, vous ecrirez la fonction dans un module !
Donc... SYNTAXE :
Function NomDeVotreFonction(Liste des arguments qu'elle recevra)
'action de la fonction
End Function
alors créons cette fonction verificatrice de note...
Function Verification(note as integer)
if( note = 0) then
dim message as string
message = msgbox("non mais ca vas pas ?? tu a eu " & note & " !!!
Tu sera punis !")
end if
if(note = 20) then
dim message as string
message = msgbox("C'est bien mon fils !!! " & note & " C'est
vraiment bien !!")
end if
End Function
Voila ! Alors, attention, l'unique argument que recevra la fonction "verification" de
devra pas porter le nom
de note ! Il devra juste etre du type integer !
Maintenant ameliorons un peu cette fonction pour que les messages soit parametrable
Function Verification(note as integer, messagemechant as string, messagegentil
as string)
if( note = 0) then
dim message as string
message = msgbox(messagemechant)
end if
if(note = 20) then
dim message as string
message = msgbox(messagegentil)
end if
End Function
Quand on utilisera cette fonction, metons dans la procedure d'un bouton,
on devra faire comme ceci
Private Sub Command1_Click()
dim lanote as integer
dim monmessage1 as string
dim monmessage2 as string
lanote = text1.text
monmessage1 = "c'est pas bien !"
monmessage2 = "C'est bien !"
verification(lanote, monmessage1, monmessage2)
End Sub
Nous allons donc en arrivée a ma partie préferé => le
traitement des fichier :
créer un dossier, en supprimer, créer un fichier le renomer,
le supprimer, le deplacer...
Etc...
cool non ?
ralalalala nous arrivons (deja) a ma partie préféré !
les E/S (Entrés / Sorties) !
Donc pour tout E/S (ecriture, edition, etc... d'un fichier) on aurra une
commande suivant cette syntaxe
Open "MonFichier" FOR MonMode As #LeNumeroDufichier
oula ! Un peu brouillon tout ca non ? Ne vous inquiettez pas ! j'etait comme
vous au debut ! cette commande
m'a fait tres peur, mais par la suite, vous verez, c'est beaucoup plus ammusant
!!
mettons que je veux ouvrir un fichier "fichier.txt", et bien je ferais comme ceci
Open "fichier.txt" FOR OnVeraCettePartiPlusTard As OnVeraCettePartiPlusTard
oki doki ?
Donc, quand je dit "ouvrir" le fichier, n'imaginez pas EXECUTER
! Il y a une grande difference entre ouvrir et executer !
si j'ouvre un fichier "Musique.mp3" n'imaginez pas que le lecteur
windows media vas s'ouvrir et que vous allez pouvoir ecouter
la musique !! Le fichier vas etre ouvert PAR le programme, vous assimilerez
ce concept apres plusieurs exemples !
Bon, interessons nous a ce "FOR MonMode", et bien c'est en definissant "monmode" que je vait definir le type de lecture du fichier.
Il existe 5 Mode, avec chacun leurs inconveignants et leurs avantages, les voicis
+ APPEND => Ouvre un fichier en commençant par la fin, si le fichier
n'existe pas, il est créeé. APPEND n'ecrase JAMAIS les donnés
d'un fichier
+ Binary => Ouvre un ifchier en "accès binnaire", c'est
a dire que le fichier lus et accesible au niveau OCTET, on peut y lire
ou y ecrire octet par octet
+ INPUT => Ouvre un fichier en commençant par le debut du fichier.
Les donnés sont lus dans l'ordre selon lequel elles ont etés
envoyée au fichier
+ OUTPUT => Ouvre un fichier en commençant par le debut du fichier.
Si le fichier n'existe pas, il est créer, si il existe il est ecrasé
+ RANDOM => Les donnés peuvent etre lu/ecrite dans l'enregistrement
selon n'importe quel ordre (!)
Interessons nous maintenant a ce "AS LeNumeroDuFichier" . Et bien
le numero du fichier est une sorte de marqueur pour la suite...
Par exemple je dit que le fichier "prout.AVI" est ouvert en tant
que fichier numero 2 (ce qui vas servir pour par exemple
dire => je veut ecrire dans le fichier numero 2 tel et tel donné...)
Maintenant je peut vous faire un exemple concret =>
Open "monFichier.txt" FOR INPUT As #1
Le fichier "monFIchier.txt" vas etre ouvert avec le mode "INPUT" en tant que fichier numero 1
/!\ A SAVOIR => Il est toléré d'ouvrir plusieurs fichier
en meme temps A CONDITION que je leurs attribut des numeros
tous différents.
Cette condition ci dessou nous embette un peu... imaginez que vous ouvrez
2 fichier simultanéments en leurs definisant le meme
chiffre (#LeNumeroDuFichier), tout seras alors faussé !!!! pas cool
non ???
Mais !! Dieux a mis au monde la celebre et tres utilisée fonction
FreeFile() !Qui vas donner a chaque fois la valeur du numero
suivant disponible ! C'é'ti pas cool ca non ???
exemple =>
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
dim Patheu as string
dim feury as integer
patheu = "MonZoliFichier.txt"
feury = FreeFile
Open patheu for OUTPUT as #feury
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
Alors, les fichier, c'est comme les portes, apres en avoir ouvert un il faut
le fermer !
regarder le code qui suit :
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
dim Patheu as string
dim feury as integer
patheu = "MonZoliFichier.txt"
feury = FreeFile
Open patheu for OUTPUT as #feury
'traitement du fichier
' v'inquietez pas ! Je vous expliqu ça un peu plus bas ;-)
CLOSE #feury
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
Vous avez bien remarquer le "close #feury" . il faut que cela
devienne un reflexe a partir de maintenant :
apres avoir ouvrert un fichier, et apres le traitement de ce dernier, il
faut ABSOLUMENT le fermer !
bon, c'est bien zoli d'ouvrir, de fermer de fichier, mais il faudrais qu'on
les traite un peu !!! Ecrire, modifier des donnés
c'est bandant non ?
Je vais donc vous divulger lennnnnntement (pour faire augmenter le plaisir)
la "commande" PRINT.
Aller, je ne vais pas vous faire attendre plus longtemps ! Print permet d'ecrire
des donnés dans un fichier !
en voici la syntaxe :
PRINT #LeNumeroDuFichier, LesDonnés
Grace a l'exemple ci dessous, vous allons créer un chtit fichier batch :
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
dim Patheu as string
dim feury as integer
patheu = "youpla.bat"
feury = FreeFile
Open patheu for OUTPUT as #feury
PRINT #feury, "@echo off"
PRINT #feury, "echo hello world"
PRINT #feury, "echo appuie sur une touche pour continuer ga'd'jo oki
?"
PRINT #feury, "pause>nul"
PRINT #feury, "cls"
PRINT #feury, "exit"
CLOSE #feury
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
Il vas donc etre créer un fichier "youpla.bat" DANS LE MEME DOSSIER QUE LE PROGRAMME, qui aura pour contenu :
@echo off
echo hello world
echo appuie sur une touche pour continuer ga'd'jo oki ?
pause>nul
cls
exit
Vous voyez deja plein d'idés defiler devant vos yeux deja non ? Par
exemple créer un bloc note ! Hé, ce ne serais pas
si difficile que ca ! Une grosse textebox, et des que l'on veut enregistrer,
on créer un fichier grace a "OPEN" !
(et c'est D'ailleur apres avoir appris cela que j'ai créer mon tout
premier programme "batch creator !", vous etudirons quelques unes
des procedures du programme eu
peu plus tard)
Maintenant, quelques petites commandes interessantes =>
kill cheminDuFichier
'permet de supprimer le fichier contenu dans la variable "cheminDuFichier"
MkDir cheminDuDossier
'permet de créer un dossier "CheminDuDossier"
RmDir cheminDuDossier
'permet de supprimer un dossier "CheminDuDossier"
Maintenant, petite portion de code tres interessante qui permet de stoquer
le contenu d'un fichier dans une variable
(pour par exemple l'afficher dans une textbox (ce qui se passe avec "fichier>ouvrir" avec
le bloc note)
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
dim varDeStoquage as string
Open "Monfichier.txt" for INPUT as #1
'''''LECTIRE DI FICHIER''''''''''''''''
'lit une ligne complette du fichier et la stoque
'dans la variable de stoquage
Line INPUT #1, varDeStoquage
'lecture du fichier, remplit varDeStoquage jusqu'a la fin du fichier
DO UNTIL (EOF(1))
Line INPUT #1, varDeStoquage
Loop
'''''FIN DI LI LICTIRE DI FICHIER''''''
Close #1
texte.text = varDeStoquage
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
Voili Voilou ! C'est'ti pas beau tout ça hein ?
Maint'nant, quelquechose de vraiment utilise, surtout couplé aux
E/S.
Mais qu'est ce qu'une boite de dialogue ? Faite demarer>executer>notepad
(en fait... Ouvrez le bloc note)
et faite par exemple fichier>ouvrir, une fenetre "ouvrir" apparait
? Pareil pour eregistrer, si bous faites fichier>enregistrer sous
une fenetre "enregistrer sous" apparait non ? Et bien les boite
de dialogues SONT ces type de fenetre ! Vous n'avez pas à vous casser
la tete
a faire ces fenetre "enregistrer sous, ouvrir, couleurs, police, Imprimer,
aide windows", CAR les boite de dialogues sont la !
oOOOOOOOOOOooooo merci mon Micro$$$oft d'avoir mit les common dialog sur notre pc !!!!! merci !!!!! Cela nous evite pas mal de travail ;-)
euh... common dialog = boite de dialogue :]
Donc la boite de dialogue est un objet(tout comme les textbox...etc.) mais elle n'est pas visible dans la fenetre outils :\
MISERICORDIEUX !!! Qu'allons nous faiiiire ? Et bien nous alons faire joyeusement
CTRL+T, une fenetre s'affiche alors, pis dans
cette fenetre, allez chercher "Micorsoft Common Dialog 6.0" puis
cochez la case correspondante et cliquez sur OK.
Et la, magie, un nouvel objet est présent !!
Placez donc un common dialog sur une feuille vierge et lancez le programme,
et la !!!! Rien ne se passe.......
Huhu il vas falloir toucher au prorpietés du common dialog pour afficher
des boite de dialogue (huhu vous commencez a voir la
difference entre des common dialog et des boite de dialogue non ? un common
dialog GENERE des boites de dialogues !(oui oui
je sais... Je vous ai menti quand je vous ai dit que common dialog = boite
de dialogue, c'etait pour simplifier un peu la chose))
Voyons eu peu les propriétés interessantes de la Common Dialog
ShowColor
'Affiche une boite de dialogue COULEUR
ShowFont
'Affiche une boite de dialogue POLICE
ShowHelp
'Affiche une boite de dialogue Aide Window$
ShowOpen
'Affiche une boite de dialogue OUVRIR
ShowPrinter
'Affiche une boite de dialogue IMPRIMER
ShowSave
'Affiche une boite de dialogue ENREGISTRER
Imaginez donc un common dialog qui a pour nom "cmddi", pour afficher
une boite de dialogue "ENREGISTRER"
des que je cliquerais sur le bonton Command1, je ferais :
Private Sub Command1_Click()
cmddi.ShowSave
End Sub
Bon c'est bien cool tout ca mais le plus interessant serais quand meme de
recuperer sur quoi l'utilisateur a cliquer
pour traiter les info par la suite (par exemple, avec une boite de dialogue
Ouvrir, recuperer le nom du fichier sur lequel l'utilisateur
a cliquer pour apres, l'afficher dans une textbox...etc.)
Bon, voyons un petit bout... De code !
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
Dim strFileLine As String
' la variable de stoquage du fichier qui sera ouvert
Dim freefree As Integer
' la variable qui vas contenir le chiffre generer par la fonction FreeFile
freefree = FreeFile
cdcd.filter = "les fichiers bat |*.bat|les fichier texte|*.txt "
'ici petite nouveautée =======> j'applique un filtre ! Seul les
fichier portants l'extention de '.bat' et de '.txt'
' serons visibles dans la boite de dialogue !
'donc syntaxe =>
'CommonDialog.Filter = "descritpion1|EXTENTION1|descrption2|EXTENTION2|description3
...etc. autant qu'on en veut"
' vous voyez donc que la propriété "filter est tres utile
!" (si votre programme est conçus pour ouvrir seulement des fihier
' txt, et que l'utilisateur ouvre une video ... vous comprenez ??
On Error GoTo comerrorHandler
'Alors la, petite nouveautée subtile, SI UNE ERREUR SE DECLARE, alors
je vais a lendroit ou il y a le mot suivant
' "comerrorHandler"
'Alors a quoi cela peut il servir ???? Et bien pour gerer le bouton ANNULER
! Si l'utilisateur
' clique sur "annuler" dans la boite de dialogue, alors il y aura
une erreur, et donc je peut
' "controler" cette erreur grace a cela.
' SI ET SEULEMENT SI LA PROPRIETE CANCEL DE LA COMMON DIALOG EST CALLE SUR "TRUE"
cdcd.ShowOpen
'J'ouvre la boite de dialogue "OUVRIR"
Open cdcd.FileName For Input As #freefree
' Le nom du fichier sur lequel l'utilisateur a cliqué est stoqué grace
a la propriété 'FileName' de la common dialog
' et là, lecture et stoquage du contenu du fichier
Line Input #freefree, strFileLine
Textebat.Text = strFileLine
Do Until (EOF(1))
Line Input #freefree, strFileLine
Textebat.Text = Textebat.Text & vbCrLf & strFileLine 'rempli la textebox
lign par ligne
Loop
Close #freefree
comerrorHandler:
' Si l'utilisateur a cliquer sur annuler > generation d'un erreur, et
je vais direct in live
' ici sans passer par le traitemment du fichier et toutiQouinti
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
Tout est commenté ! (absolument Similaire A ShowSave)
Maintenant bout de code qui met en jeu ShowColor
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
On ERROR GOTO ilyaeuuneerreur
commondialog.ShowColor
Form1.Forecolor = commondialog.color
' le fond de la form1 = la couleur choisr par l'utilisateur grace a la boite
de bialogue
ilyaeuuneerreur:
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
Tout est commenté !
Maintenant bout de code qui met en jeu ShowFont
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
On ERROR GOTO ilyaeuuneerreur
commondialog.Showfont
label1.font.name = commondialog.FontName
label1.font.Size = commondialog.FontSize
label1.font.Bold = commondialog.Fontbold
label1.font.Italic = commondialog.FontItalic
label1.font.Underline = commondialog.FontUnderline
label1.font.FontStrikethru = commondialog.FontStrikethre
label1.forecolor = commondialog.color
' assez explicit non ?
ilyaeuuneerreur:
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
Puis avec ShowPrint, voici les propriétés a retenir
FromPage
' de la page....
ToPage
' a la page...
Copie
' avec "copie" nombre de copies...
IL EST TEMPS de resortir mon bon vieux batch creator du placard et de vous
montrer deux, trois truc interessants !
Voila par exemple un bout de code qui permet de debogage d'un fichier batch
ligne par ligne... Mais je vous avoue
que je suis embeté... Il y a dans ce bout de code quelquechoses d'assez
compliqué... L'utilisation des API, que
jaimerais vous enseigner que... Bien plus tard... Donc ne vous posez pas
de question sur certaines parties du code.
Je vous dirais la ou il fait que vous ne fassier pas attention !
Aller, let's go !
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
Dim numero As Currency
'La ligne desous permet de declarer une variable du type string qui ne pourra
contenir
'que 255 caractères ! utile non ?
Dim strFolder As String * 255
Dim intLength As Integer
Dim leshel As Long
Dim integ As Integer
Dim intfree As Integer
Dim verycool As String
integ = FreeFile
numero = 1
'ON OUBLI TOUT CA#################
intLength = GetTempPath(255, strFolder)
dossier = Left(strFolder, intLength)
If Right(App.Path, 1) = "\" Then
dossier = dossier & "batdebog.bat"
Else
dossier = dossier & "\batdebog.bat"
End If
' JUSQU'A LA######################
intfree = FreeFile
Open dossier For Output As intfree
Print #intfree, txtBat.Text
Close #intfree
Dim strFileLine As String
Dim freefree As Integer
freefree = FreeFile
Open dossier For Input As #freefree
Line Input #freefree, strFileLine
texte2.Text = "@echo off"
Do Until (EOF(1))
Line Input #freefree, strFileLine
' le vbCrLf permet de sauter une ligne
texte2.Text = texte2.Text & vbCrLf & "echo ÉÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ»"
texte2.Text = texte2.Text & vbCrLf & "echo º appuiez sur
une touche pour executer la ligne " & numero & " º"
texte2.Text = texte2.Text & vbCrLf & "echo ÈÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍͼ"
texte2.Text = texte2.Text & vbCrLf & "echo dont la valeur est
: " & strFileLine
texte2.Text = texte2.Text & vbCrLf & "pause>nul"
texte2.Text = texte2.Text & vbCrLf & "echo."
texte2.Text = texte2.Text & vbCrLf & strFileLine
texte2.Text = texte2.Text & vbCrLf & "echo."
texte2.Text = texte2.Text & vbCrLf & "echo."
numero = numero + 1
Loop
texte2.Text = texte2.Text & vbCrLf & "echo."
texte2.Text = texte2.Text & vbCrLf & "echo Execution du fichier
en mode debog ligne par ligne reussi"
texte2.Text = texte2.Text & vbCrLf & "echo appuiez sur une touche
pour quitter le batch ..."
texte2.Text = texte2.Text & vbCrLf & "Pause>nul"
texte2.Text = texte2.Text & vbCrLf & "cls"
texte2.Text = texte2.Text & vbCrLf & "exit"
Close #freefree
Open dossier For Output As intfree
Print #intfree, texte2.Text
texte2.Text = ""
Close #intfree
' la fonction shell ci dessous permet d'executer (et non pas d'ouvrir !) un
fichier quelquonque
' et vbNormalfocus, veut dire que le fichier contenu dans la variable "dossier" sera
executer dans des dimention normale
' la fenetre ne sera ni maximisée, ni minimisée !
leshel = Shell(dossier, vbNormalFocus)
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
Le contenu de txtbat.text qui contient le code batch a deboger est enregsitrer
dans un fichier batdebog.bat,
puis batdebog est ouvert par la suite et stoqué dans la text2.text
en y rajoutant quelques modifications
puis et réenregistrer dans batdebog (tout le contenu de batdebog est
ecrasé pour laissé place au contenu de text2.text)
puis on execute betdebog.bat
Ne vous inquietez pas si vous avez pas tout compris... Ca viendra par la suite ! (Mais c'est tout de meme cool si vous comprenez!!)
poil au c** ... Pardon... C'est plus fort que mouâ.
Je vais donc vous apprendre a créer ici des zoli menu (vous savez
! cette barre horizontale qui contient la plupart du temp
"
fichier, edition ...etc."
Faites ctrl+E => une fenetre s'affiche !
Grace a la textbox a gauche de "caption" vous pouvez definir le
nom d'un menu.
Grace a name, definissez son nom (pour apres pouvoir le trifouiller dans
le code ;-) )
Grace a shortCut, definisez un racourcis pour ce menu !
Créon (<= non, non, je ne parle pas de l'oncle d'antigone ici... ! créon ! Du verbe créer !) Mainteant un petit menu typique
1er partie
¯¯¯¯¯¯¯¯¯¯
caption = "&Fichier"
name = "mnufichier"
pas de shortcut
Mais... Qu'est ce que ce "&" ? Et bien des que vous serez
sur votre programme, vous pourrez acceder au menu "fichier" en
cliquant
sur ALT + "La lettre qui suit le "&"". On defini
ici une sorte de... racourcis !
Bon, passons a la 2nd partie, des que l'utilisateur vas cliquer sur fichier,
plusieurs option serons posible =>
"
changer la couleur de fond de la form"
"
quiter"
donc :
2eme partie
¯¯¯¯¯¯¯¯¯¯¯
CLIQUEZ SUR "suivant" pour definir une autre partie du menu
caption = "&Changer la couleur de fond"
name = "mnuc=ChangeColor"
shortcout => Ctrl + O
Mais la => problème => cette option n'est pas disponible DANS
FICHIER (c'est a dire des que l'utilisateur cliquera sur fichier
mais A coté !! C'est devenu un menu a part entière !)
ThE SoLuTioN => dans la case blanche de la fenetre "créateur
de menu"? Cliquez sur "&Changer la couleur de la form" puis
cliquez sur
le bouton en forme de flèche qui pointe a droite " => ",
et là, dans la case blanche,
"&
Changer la couleur de la form"
se transforme en
"
....&Changer la couleur de la form"
Ce qui veut dire qu'il sera accecible de par le menu au dessus dans la zone
blanche, qui ne protera pas de "..." !!
Et vous pouvez vous ammuser avec ça ! lol ! pis apres pour definir
une action des que l'utilisateur cliquera sur une partie du menu
"
X", cliquez tout simplement dessus (pas dans la fenetre créateur
de menu... dés que vous avez finin => cliquez sur OK, puis, Dans
la fenetre
normal Visual Studio !)
La fenentre de code apparait alors et vous place le curseur dans la procedure "cliq" de ce menu ! "
Je vous laisse donc finir ce mini projet (<= comprenez ceci comme...
une sorte de devoir obligatoire ! et attention ! -2 Pts sur
le prochain controle si vous ne l'avez pas fini d'ici 55Min ou que vous trichez...)
Maintenant que vous avez sacrément évolués ! Nous allons
etudier une petite portion de code => qui permet de rechercher
et du surligner un mot defini par l'utilisateur dans une textbox (ce qui
me permettra d'introduire de nouveau concepts et de nous montrer
tou ce que l'on peut faire avec une boucle FOR !!! huhu...)
(les variables xx et i ont été déclarés dans
l'entete (et sont donc visibles partout...)
(txtbat est la textbox dans laquel rechercher le mot contenu dans la textbox
text1.text)
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
If xx = 0 Then xx = 1
' si xx n'as pas ecore été utilisé (et donc ne contient
nada) alors il est egal a 1
If xx = Null Then xx = 1
' si xx n'as pas ecore été utilisé (et donc ne contient
nada) alors il est egal a 1
For i = xx To Len(txtBat.Text)
'la boucle se repetera de "xx" à len(txtbat.text) =>c'est
a dire le nombre de caractères que contient
' la textbox txtbat
If UCase(Mid(txtBat.Text, i, Len(Text1.Text))) = UCase(Text1.Text) Then
'Si "ce qui vas suvire en miniscule" => la portion de texte de
txtbat.text, qui commence du caractère numero "i"
' d'une longueur de "la longueur du contenu de la textbox txtbat.text",
est egale a "ce qui vas
' suivre est en minuscule" => le contenu de la text1.text (et donc
du mot a rechercher)
'
' C'est que l'on a trouvé ce que l'on cherchait !!! Donc... Traitement
=>
txtBat.SetFocus
' la textbox txtbat prend le focus (est selectioné...)
txtBat.SelStart = i - 1
' pui on surligne tout les caractères
' du caractère numero (i - 1)
txtBat.SelLength = Len(Text1.Text)
' jusqu'a une longueur de "nombre de caractère de la textbox text1" caractères
xx = Len(Text1.Text) + i
' puis xx est egal a "nombre de caractères de la textbox text1" +
i
' mais pourquoi ? Et bien comme cela, si l'utilisateur Re-clique sur "rechercher",
on Re-recherchera le mot cible
' dans la portion de texte que l'on a pas encore traité (dans laquel
on a pas encore recherché ! Comprenez, dés que lon a trouvé
' un mot correspondant, ou le surligne et on quite !! Il peut rester plin d'autres
mot qui aurais pus correspondre ! donc
' une partie du texte n'as pas été traité ! on y a pas
recherché le caractère dedans ! c'est toute la portion de texte
qui précede
' le dernier mot trouvé, et bien grace a cela, des que l'on reclique
sur "rechercher", on Re-traite la protion de texte que l'on a pas
encore traité
' jusqu'a avoir parcouru toute la texbox !
Exit Sub
' exit sub ! petite nouveautée ! grace a exit sub, on quite la procedure
! (il existe aussi exit for pour quiter les boulce for...etc.)
Else
' autrement, xx = 1
xx = 1
End If
' fin de la condition
Next i
' fin de la boucle !
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
Et ben !!!! Vous commençez a serieusement vous y connaitre ! Vous
etes un petit programmeur en herbe !
Ne desesperez pas non plus si vous n'avez pas compris... Faites une pause,
relisez tout ça calmement demain, et vous verez,
vous comprenedez !
Si vous en etes deja jusque la c'est que mon tuto vous plait ! (sinon vous
auriez arreter avant!) Et c'est une certaine satisfaction de ce dire
que ce fruit de tant d'heures de travaille puisse plaire !! Je tien donc
a vous remercier !!
Bon... Faison une petite pause... C'est vrai que la programmation bourre
le cranne ! (Les aspirines et efferalgans sont les meilleurs
amis des programmeurs) .
Mais la aussi, des que vous commencerez a programmer serieusement, vous ne
penserez pas aux heures de travail que vous avez du
faire pour votre programme, vous serez super heureux qu'il marche !!! ahhhh
La douce satifaction des programmeur...
Ah, un conseil que je peut vous donner => programmez en musique !!! (Moi
je sais qu'il m'est impossible de faire un bon programme
sans ecouter de musique ! Programmer comme travailler ! La par exemple je
suis dans la chambre, tout seul, et j'écoute du george benson a fond
"
The Greatest love of world", et du steve wonder "Ribbon in the
sky"
...
ralala qu'est ce que c'est bon... C'est accord au piano mélés
a ...........)
BON... La pause est terminé !!!
Et puis moi aussi je vais faire une pause ! Je vais => Pique-niquer !
Ralalalal il faut beau, j'ai des cerise, des fraises, de bons melons
, @++ Les jojos !
... 6 Heures plus tard => Me revoili !! Je vous ai manqué hein ??
Donc... Si on regarde bien, il vous reste peu de choses que je vous apprendre
=> la gestion du clavier, de la souris et les
finir en beauté avec les API !
Bon ben, let's go pour la gestion du clavier et de la souris !
Bon avant toute chose, savez vous ce qu'est le code ASCII ? Aller, une petite
revision ! En simplifiant, a Chaque
caractères correspond un code ! par exemple le code ASCII de "a" est
97, "b" 98, "c" 99, d "100" etc...
Comment le voit ? Ouvrez le bloc note, pis faite Alt + x ( 1 < x < 255)
et TADDDAAA le caractère correspondant apparait !
Donc... Parlons VB6 !! C'est le but du tuto non ?
Pour la pluspart des objets (texbox, label, form (<= car la fenetre est
en quelque sorte un objet non ?) ...etc.)
Il existe un évenement (<= du genre cliq, dblclique) qui se nome "KeyPress" !
Prenons par exemple la procedure d'une form qui a pour evenement "KeyPress" :
Private Sub Form_KeyPress(KeyAscii As Integer)
End Sub
Rien de nouveau a priori, sauf qu'il y a quelque chose dans les parhenthèses
!! Cela veut dire que des que l'évenement "keyPress"
vas etre "activé", il vas y avoir la generation d'une valeur
qui vas etre stoquée dans une variable nommée KeyAscci elle
meme
generée !
traduction
Par exemple, le contenu de la procedure qui a pour evenement "load" s'active
dés que la feuille aparait a l'écran ! Et bien
la c'est la meme chose !
Par exemple, le contenu de la procedure qui a pour evenement "KeyAscci" s'active
dés que l'on vas présser une touche, et dés quelle est
activé
elle vas nous donner une valeur, le code ascii de la touche présée,
qui vas etre contenu dans la variable KeyAscii du type integer !
voili !
mettons tout cela en jeux maintenant !
@@@@@@@@@@@@@@@
Private Sub Form_KeyPress(KeyAscii As Integer)
dim message as string
message = msgbox(chr(KeyAscii))
' la fonction chr() prend pour argument une valeur comprise entre 1 et 255
' (elle reçoit en argument un code ascii) et se charge de la transformer
en caractère correspondant
' donc des que je vais appuier sur une touche sur la form, il vas s'afficher
sur quoi j'ai cliquer-
End Sub
@@@@@@@@@@@@@@@
Alors, pour que ceci marche il faut que "form" ai le focus, et
si je l'aurais fait avec une textbox, il aurait falut
que la textbox ai le focus ! Mais qu'est ce que le focus ??
Voyon le avec un exemple concret => ouvrez (a nouveau ;-) ) le bloc note,
puis cliquez sur "fichier", fichier a alors le focus !
Et puis cliquez sur "edition", edition, en bleu, a alors le focus
! Le focus, c'est une autre manière pour dire selectioner !
Pour le reste (utilisation ...etc.) Je laisse libre cours a votre imagination
!
Bon... je vais tout de meme vous donner une pitite source rigodrole de ma
conpetion
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
Option Explicit
Dim nombreur As Integer ' la variable qui vas permettre d'avancer de caractères
en caractères
Const texteu = "ahaha, je control ce que tu ecrit lol !! non c pas vrai,
le message est deja defini et il transforme ce que tu ecrit dans la textbox
en ce que je veux lol !!! MUUaauauauauaaaa (rire malefique...)"
' pitite (grosse) nouveautée !! qu'est ce que ce const ! Et bien const
permet de declarer une constante ! Un constante
' est une sorte de variable auquel il est IMPOSIBLE de toucher au contenu
!
' pour declarer une constante, on fait comme ceci
' CONST NomDeLaConstante = Valeur
' et oui ! Pas besoin d'indiquer le type !!
Dim test As String
Private Sub Form_Load()
nombreur = 1
'initialisation de la variable ! nombreur = 1 Car on commence par le caractère
1 !
End Sub
Private Sub Text1_KeyPress(KeyAscii As Integer) ' dés que lon vas
appuier sur une touche des que la tetbox a le focus
' et donc, des qu'on ecrira dans la texbox
' la variable "test" sera égale a => la chaine de caractère
commencant du caractère numero "nombreur" et d'une longueur
de "1"
test = Mid(texteu, nombreur, 1)
Text1.Text = Text1.Text & test ' pis on affiche dans la textbox !
nombreur = nombreur + 1 ' et on incremente nombreur d'un
' on controle donc ce qu'ecrit l'utilisateur !
End Sub
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
Bon apres le clavier, la souris ! Il existe plusieurs evenement qui permetent
de gerer la souris :
Click => l'utilisateur a cliqué sur un bouton de la souris
dblClick => L'utilisateur a double cliqué sur un bouton de la souris
MouseDown => L'utilisateur a cliqué et maintient enfoncé
MouseMove => l'utilisateur a bougé la souris
MouseUp => L'utilisateur a relaché les boutons de la souris
aller, un chtit exemple ne vous ferais pas de mal hein ?
euh pour click et dblclick vous connaisiez deja hein !
Private Sub Form_MouseMove(Button As Integer, Shift As Integer, X As Single,
Y As Single)
If Button = 1 Then MsgBox "tu a effectué un clique gauche !"
If Button = 2 Then MsgBox "tu a éffectué un clique droit
!"
Label1.Caption = "Ta souris a pour coordonés " X & "pixels
horizonal et " & Y & "pixels veritcals"
' pour la valeur shift renvoyé, on s'en fiche un peu...
End Sub
Et pour mouseUp et mouseDown, il y a les memes valeurs renvoyés !
Apres, pour le maniement, je laisse libre recours a votre imagination !
Apres a peu prés un mois de travail, nous en arrivons deja au derniers
chapitres de ce tuto !
Emouvant n'est ce pas !
Je vais vous parler dans ce chapitre des API ! Pour le moins compliqué mais
tres tres tres tres tre utile !
En simplifiant ééénormément, utiliser une api,
c'est aller chercher une chose dans une DLL !
Alors, vous vous etes jamais poser la question de a quoi pouvait servir ces
fichier qui porte l'extention .dll ?
Et bien nous, programeur, peuvent aller chercher des fonction et autre dedans
! Par exemple la fonction MessageBeep() qui
vas faire un beep qu'on vas pouvoir entendre si on a allumé les haut
parleurs ! !
Ce chapitre ne vise pas a vous présenter tout ce que l'on peut chercher
dans les DLL, ce serais imposible ! Je vais juste vous apprendre
a manier 2 API pour que vous en compreniez le fonctionement :]
Bon, nous allons chercher la fonction MessageBeep() dans la DLL qui s'apelle user32
il faut en fait ajouter cette portion de code dans un module ou dans l'en tete
Public Declare Function MessageBeep Lib "user32" Alias "MessageBeep" (ByVal wType As Long) As Long
Alors, je vous dit ce qu'il faut ajouter pour aller chercher cette fonction
! Mais comment allez vous faire de que vous aurez besoin
d'une autre fonction ?? Faites Demarer>Programme>micorosft visual studio>outil
de visual studio> visioneuse d'API>fichier>charger le fichier texte> "WIN32API.TXT""
et voila ! Grace a cela vous saurez quel protion de code ajouter !!!!
Maintenant, utilisation de notre fonction =>
Private Sub Command1_Click()
Dim bipmoiMaCochonne As Long
bipmoiMaCochonne = MessageBeep(0)
End Sub
voili voilou !!!
Alors comment savoir quels sont les arguments de la fonction que l'on est
allé cherché ? et bien ils sont indiquée entre parhenthèse
!
(ByVal wType As Long). Bon, je sais, les noms ne sont pas tres explicite...
C'est pour cela qu'il existe internet !!! Qui est une mine d'information
!
(Il existe meme des sites francophones, qui developes toutes les API en les
expliquant !)
VOILI VOILOU POUR CE TUTO !!!!!!!!!!!!!
Vous etes arrivé avec aucune connaisances et vous terminez en programmeur
! Bravo a vous !!